tests/phpunit/includes/db/LBFactoryTest.php

   1 <?php
   2
   3 use Wikimedia\Rdbms\LBFactorySimple;
   4 use Wikimedia\Rdbms\LBFactoryMulti;
   5 use Wikimedia\Rdbms\ChronologyProtector;
   6
   7 /**
   8  * Holds tests for LBFactory abstract MediaWiki class.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along
  21  * with this program; if not, write to the Free Software Foundation, Inc.,
  22  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  23  * http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * @group Database
  26  * @file
  27  * @author Antoine Musso
  28  * @copyright © 2013 Antoine Musso
  29  * @copyright © 2013 Wikimedia Foundation Inc.
  30  */
  31 class LBFactoryTest extends MediaWikiTestCase {
  32
  33         /**
  34          * @dataProvider getLBFactoryClassProvider
  35          */
  36         public function testGetLBFactoryClass( $expected, $deprecated ) {
  37                 $mockDB = $this->getMockBuilder( 'DatabaseMysqli' )
  38                         ->disableOriginalConstructor()
  39                         ->getMock();
  40
  41                 $config = [
  42                         'class'          => $deprecated,
  43                         'connection'     => $mockDB,
  44                         # Various other parameters required:
  45                         'sectionsByDB'   => [],
  46                         'sectionLoads'   => [],
  47                         'serverTemplate' => [],
  48                 ];
  49
  50                 $this->hideDeprecated( '$wgLBFactoryConf must be updated. See RELEASE-NOTES for details' );
  51                 $result = MWLBFactory::getLBFactoryClass( $config );
  52
  53                 $this->assertEquals( $expected, $result );
  54         }
  55
  56         public function getLBFactoryClassProvider() {
  57                 return [
  58                         # Format: new class, old class
  59                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactory_Simple' ],
  60                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactory_Single' ],
  61                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactory_Multi' ],
  62                         [ Wikimedia\Rdbms\LBFactorySimple::class, 'LBFactorySimple' ],
  63                         [ Wikimedia\Rdbms\LBFactorySingle::class, 'LBFactorySingle' ],
  64                         [ Wikimedia\Rdbms\LBFactoryMulti::class, 'LBFactoryMulti' ],
  65                 ];
  66         }
  67
  68         public function testLBFactorySimpleServer() {
  69                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
  70
  71                 $servers = [
  72                         [
  73                                 'host'        => $wgDBserver,
  74                                 'dbname'      => $wgDBname,
  75                                 'user'        => $wgDBuser,
  76                                 'password'    => $wgDBpassword,
  77                                 'type'        => $wgDBtype,
  78                                 'dbDirectory' => $wgSQLiteDataDir,
  79                                 'load'        => 0,
  80                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
  81                         ],
  82                 ];
  83
  84                 $factory = new LBFactorySimple( [ 'servers' => $servers ] );
  85                 $lb = $factory->getMainLB();
  86
  87                 $dbw = $lb->getConnection( DB_MASTER );
  88                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
  89
  90                 $dbr = $lb->getConnection( DB_SLAVE );
  91                 $this->assertTrue( $dbr->getLBInfo( 'master' ), 'DB_SLAVE also gets the master' );
  92
  93                 $factory->shutdown();
  94                 $lb->closeAll();
  95         }
  96
  97         public function testLBFactorySimpleServers() {
  98                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
  99
 100                 $servers = [
 101                         [ // master
 102                                 'host'        => $wgDBserver,
 103                                 'dbname'      => $wgDBname,
 104                                 'user'        => $wgDBuser,
 105                                 'password'    => $wgDBpassword,
 106                                 'type'        => $wgDBtype,
 107                                 'dbDirectory' => $wgSQLiteDataDir,
 108                                 'load'        => 0,
 109                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 110                         ],
 111                         [ // emulated slave
 112                                 'host'        => $wgDBserver,
 113                                 'dbname'      => $wgDBname,
 114                                 'user'        => $wgDBuser,
 115                                 'password'    => $wgDBpassword,
 116                                 'type'        => $wgDBtype,
 117                                 'dbDirectory' => $wgSQLiteDataDir,
 118                                 'load'        => 100,
 119                                 'flags'       => DBO_TRX // REPEATABLE-READ for consistency
 120                         ]
 121                 ];
 122
 123                 $factory = new LBFactorySimple( [
 124                         'servers' => $servers,
 125                         'loadMonitorClass' => 'LoadMonitorNull'
 126                 ] );
 127                 $lb = $factory->getMainLB();
 128
 129                 $dbw = $lb->getConnection( DB_MASTER );
 130                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 131                 $this->assertEquals(
 132                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 133                         $dbw->getLBInfo( 'clusterMasterHost' ),
 134                         'cluster master set' );
 135
 136                 $dbr = $lb->getConnection( DB_SLAVE );
 137                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 138                 $this->assertEquals(
 139                         ( $wgDBserver != '' ) ? $wgDBserver : 'localhost',
 140                         $dbr->getLBInfo( 'clusterMasterHost' ),
 141                         'cluster master set' );
 142
 143                 $factory->shutdown();
 144                 $lb->closeAll();
 145         }
 146
 147         public function testLBFactoryMulti() {
 148                 global $wgDBserver, $wgDBname, $wgDBuser, $wgDBpassword, $wgDBtype, $wgSQLiteDataDir;
 149
 150                 $factory = new LBFactoryMulti( [
 151                         'sectionsByDB' => [],
 152                         'sectionLoads' => [
 153                                 'DEFAULT' => [
 154                                         'test-db1' => 0,
 155                                         'test-db2' => 100,
 156                                 ],
 157                         ],
 158                         'serverTemplate' => [
 159                                 'dbname'          => $wgDBname,
 160                                 'user'            => $wgDBuser,
 161                                 'password'        => $wgDBpassword,
 162                                 'type'            => $wgDBtype,
 163                                 'dbDirectory' => $wgSQLiteDataDir,
 164                                 'flags'           => DBO_DEFAULT
 165                         ],
 166                         'hostsByName' => [
 167                                 'test-db1'  => $wgDBserver,
 168                                 'test-db2'  => $wgDBserver
 169                         ],
 170                         'loadMonitorClass' => 'LoadMonitorNull'
 171                 ] );
 172                 $lb = $factory->getMainLB();
 173
 174                 $dbw = $lb->getConnection( DB_MASTER );
 175                 $this->assertTrue( $dbw->getLBInfo( 'master' ), 'master shows as master' );
 176
 177                 $dbr = $lb->getConnection( DB_SLAVE );
 178                 $this->assertTrue( $dbr->getLBInfo( 'replica' ), 'slave shows as slave' );
 179
 180                 $factory->shutdown();
 181                 $lb->closeAll();
 182         }
 183
 184         public function testChronologyProtector() {
 185                 // (a) First HTTP request
 186                 $mPos = new MySQLMasterPos( 'db1034-bin.000976', '843431247' );
 187
 188                 $now = microtime( true );
 189                 $mockDB = $this->getMockBuilder( 'DatabaseMysqli' )
 190                         ->disableOriginalConstructor()
 191                         ->getMock();
 192                 $mockDB->method( 'writesOrCallbacksPending' )->willReturn( true );
 193                 $mockDB->method( 'lastDoneWrites' )->willReturn( $now );
 194                 $mockDB->method( 'getMasterPos' )->willReturn( $mPos );
 195
 196                 $lb = $this->getMockBuilder( 'LoadBalancer' )
 197                         ->disableOriginalConstructor()
 198                         ->getMock();
 199                 $lb->method( 'getConnection' )->willReturn( $mockDB );
 200                 $lb->method( 'getServerCount' )->willReturn( 2 );
 201                 $lb->method( 'parentInfo' )->willReturn( [ 'id' => "main-DEFAULT" ] );
 202                 $lb->method( 'getAnyOpenConnection' )->willReturn( $mockDB );
 203                 $lb->method( 'hasOrMadeRecentMasterChanges' )->will( $this->returnCallback(
 204                                 function () use ( $mockDB ) {
 205                                         $p = 0;
 206                                         $p |= call_user_func( [ $mockDB, 'writesOrCallbacksPending' ] );
 207                                         $p |= call_user_func( [ $mockDB, 'lastDoneWrites' ] );
 208
 209                                         return (bool)$p;
 210                                 }
 211                         ) );
 212                 $lb->method( 'getMasterPos' )->willReturn( $mPos );
 213
 214                 $bag = new HashBagOStuff();
 215                 $cp = new ChronologyProtector(
 216                         $bag,
 217                         [
 218                                 'ip' => '127.0.0.1',
 219                                 'agent' => "Totally-Not-FireFox"
 220                         ]
 221                 );
 222
 223                 $mockDB->expects( $this->exactly( 2 ) )->method( 'writesOrCallbacksPending' );
 224                 $mockDB->expects( $this->exactly( 2 ) )->method( 'lastDoneWrites' );
 225
 226                 // Nothing to wait for
 227                 $cp->initLB( $lb );
 228                 // Record in stash
 229                 $cp->shutdownLB( $lb );
 230                 $cp->shutdown();
 231
 232                 // (b) Second HTTP request
 233                 $cp = new ChronologyProtector(
 234                         $bag,
 235                         [
 236                                 'ip' => '127.0.0.1',
 237                                 'agent' => "Totally-Not-FireFox"
 238                         ]
 239                 );
 240
 241                 $lb->expects( $this->once() )
 242                         ->method( 'waitFor' )->with( $this->equalTo( $mPos ) );
 243
 244                 // Wait
 245                 $cp->initLB( $lb );
 246                 // Record in stash
 247                 $cp->shutdownLB( $lb );
 248                 $cp->shutdown();
 249         }
 250
 251         private function newLBFactoryMulti( array $baseOverride = [], array $serverOverride = [] ) {
 252                 global $wgDBserver, $wgDBuser, $wgDBpassword, $wgDBname, $wgDBtype, $wgSQLiteDataDir;
 253
 254                 return new LBFactoryMulti( $baseOverride + [
 255                         'sectionsByDB' => [],
 256                         'sectionLoads' => [
 257                                 'DEFAULT' => [
 258                                         'test-db1' => 1,
 259                                 ],
 260                         ],
 261                         'serverTemplate' => $serverOverride + [
 262                                 'dbname' => $wgDBname,
 263                                 'user' => $wgDBuser,
 264                                 'password' => $wgDBpassword,
 265                                 'type' => $wgDBtype,
 266                                 'dbDirectory' => $wgSQLiteDataDir,
 267                                 'flags' => DBO_DEFAULT
 268                         ],
 269                         'hostsByName' => [
 270                                 'test-db1' => $wgDBserver,
 271                         ],
 272                         'loadMonitorClass' => 'LoadMonitorNull',
 273                         'localDomain' => wfWikiID()
 274                 ] );
 275         }
 276
 277         public function testNiceDomains() {
 278                 global $wgDBname, $wgDBtype;
 279
 280                 if ( $wgDBtype === 'sqlite' ) {
 281                         $tmpDir = $this->getNewTempDirectory();
 282                         $dbPath = "$tmpDir/unit_test_db.sqlite";
 283                         file_put_contents( $dbPath, '' );
 284                         $tempFsFile = new TempFSFile( $dbPath );
 285                         $tempFsFile->autocollect();
 286                 } else {
 287                         $dbPath = null;
 288                 }
 289
 290                 $factory = $this->newLBFactoryMulti(
 291                         [],
 292                         [ 'dbFilePath' => $dbPath ]
 293                 );
 294                 $lb = $factory->getMainLB();
 295
 296                 if ( $wgDBtype !== 'sqlite' ) {
 297                         $db = $lb->getConnectionRef( DB_MASTER );
 298                         $this->assertEquals(
 299                                 $wgDBname,
 300                                 $db->getDomainID()
 301                         );
 302                         unset( $db );
 303                 }
 304
 305                 /** @var Database $db */
 306                 $db = $lb->getConnection( DB_MASTER, [], '' );
 307                 $lb->reuseConnection( $db ); // don't care
 308
 309                 $this->assertEquals(
 310                         '',
 311                         $db->getDomainID()
 312                 );
 313
 314                 $this->assertEquals(
 315                         $this->quoteTable( $db, 'page' ),
 316                         $db->tableName( 'page' ),
 317                         "Correct full table name"
 318                 );
 319
 320                 $this->assertEquals(
 321                         $this->quoteTable( $db, $wgDBname ) . '.' . $this->quoteTable( $db, 'page' ),
 322                         $db->tableName( "$wgDBname.page" ),
 323                         "Correct full table name"
 324                 );
 325
 326                 $this->assertEquals(
 327                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 328                         $db->tableName( 'nice_db.page' ),
 329                         "Correct full table name"
 330                 );
 331
 332                 $factory->setDomainPrefix( 'my_' );
 333                 $this->assertEquals(
 334                         '',
 335                         $db->getDomainID()
 336                 );
 337                 $this->assertEquals(
 338                         $this->quoteTable( $db, 'my_page' ),
 339                         $db->tableName( 'page' ),
 340                         "Correct full table name"
 341                 );
 342                 $this->assertEquals(
 343                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 344                         $db->tableName( 'other_nice_db.page' ),
 345                         "Correct full table name"
 346                 );
 347
 348                 $factory->closeAll();
 349                 $factory->destroy();
 350         }
 351
 352         public function testTrickyDomain() {
 353                 global $wgDBtype;
 354
 355                 if ( $wgDBtype === 'sqlite' ) {
 356                         $tmpDir = $this->getNewTempDirectory();
 357                         $dbPath = "$tmpDir/unit_test_db.sqlite";
 358                         file_put_contents( $dbPath, '' );
 359                         $tempFsFile = new TempFSFile( $dbPath );
 360                         $tempFsFile->autocollect();
 361                 } else {
 362                         $dbPath = null;
 363                 }
 364
 365                 $dbname = 'unittest-domain';
 366                 $factory = $this->newLBFactoryMulti(
 367                         [ 'localDomain' => $dbname ],
 368                         [ 'dbname' => $dbname, 'dbFilePath' => $dbPath ]
 369                 );
 370                 $lb = $factory->getMainLB();
 371                 /** @var Database $db */
 372                 $db = $lb->getConnection( DB_MASTER, [], '' );
 373                 $lb->reuseConnection( $db ); // don't care
 374
 375                 $this->assertEquals(
 376                         '',
 377                         $db->getDomainID()
 378                 );
 379
 380                 $this->assertEquals(
 381                         $this->quoteTable( $db, 'page' ),
 382                         $db->tableName( 'page' ),
 383                         "Correct full table name"
 384                 );
 385
 386                 $this->assertEquals(
 387                         $this->quoteTable( $db, $dbname ) . '.' . $this->quoteTable( $db, 'page' ),
 388                         $db->tableName( "$dbname.page" ),
 389                         "Correct full table name"
 390                 );
 391
 392                 $this->assertEquals(
 393                         $this->quoteTable( $db, 'nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 394                         $db->tableName( 'nice_db.page' ),
 395                         "Correct full table name"
 396                 );
 397
 398                 $factory->setDomainPrefix( 'my_' );
 399
 400                 $this->assertEquals(
 401                         $this->quoteTable( $db, 'my_page' ),
 402                         $db->tableName( 'page' ),
 403                         "Correct full table name"
 404                 );
 405                 $this->assertEquals(
 406                         $this->quoteTable( $db, 'other_nice_db' ) . '.' . $this->quoteTable( $db, 'page' ),
 407                         $db->tableName( 'other_nice_db.page' ),
 408                         "Correct full table name"
 409                 );
 410
 411                 \MediaWiki\suppressWarnings();
 412                 $this->assertFalse( $db->selectDB( 'garbage-db' ) );
 413                 \MediaWiki\restoreWarnings();
 414
 415                 $this->assertEquals(
 416                         $this->quoteTable( $db, 'garbage-db' ) . '.' . $this->quoteTable( $db, 'page' ),
 417                         $db->tableName( 'garbage-db.page' ),
 418                         "Correct full table name"
 419                 );
 420
 421                 $factory->closeAll();
 422                 $factory->destroy();
 423         }
 424
 425         private function quoteTable( Database $db, $table ) {
 426                 if ( $db->getType() === 'sqlite' ) {
 427                         return $table;
 428                 } else {
 429                         return $db->addIdentifierQuotes( $table );
 430                 }
 431         }
 432 }